package com.fidelizarte.ejb.servicio.fromend.impl;

import java.util.ArrayList;
import java.util.List;

import com.fidelizarte.common.util.SeguridadesException;
import com.fidelizarte.ejb.persistence.dao.impl.EmpresaDAO;
import com.fidelizarte.ejb.persistence.dao.impl.PersonaDAO;
import com.fidelizarte.ejb.persistence.dao.impl.TipoCampaniaDAO;
import com.fidelizarte.ejb.persistence.dao.impl.TipoPersonaDAO;
import com.fidelizarte.ejb.persistence.dto.EmpresaDTO;
import com.fidelizarte.ejb.persistence.dto.TipoCampaniaDTO;
import com.fidelizarte.ejb.persistence.entities.Empresa;
import com.fidelizarte.ejb.persistence.entities.Persona;
import com.fidelizarte.ejb.persistence.entities.TipoCampania;
import com.fidelizarte.ejb.persistence.entities.TipoPersona;
import com.fidelizarte.ejb.persistence.util.dto.EmpleadoDTO;
import com.fidelizarte.ejb.persistence.dto.CargoDTO;
import com.fidelizarte.ejb.servicio.frontend.ServicioCommonRemote;

import javax.ejb.EJB;
import javax.ejb.Remote;
import javax.ejb.Stateless;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * Session Bean implementation class ServicioCommonImpl
 */
@Stateless
@Remote(ServicioCommonRemote.class)
public class ServicioCommonImpl implements ServicioCommonRemote {

	private static final Logger log = LoggerFactory
			.getLogger(ServicioCommonImpl.class);
	@EJB
	private EmpresaDAO empresaDAO;
	@EJB
	private TipoPersonaDAO tipoPersonaDAO;
	@EJB
	private TipoCampaniaDAO tipoCampaniaDAO;
	@EJB
	private PersonaDAO personaDAO;
	private Empresa empresa;
	//private TipoPersona tipoPersona;

	private EmpresaDTO empresaDTO = new EmpresaDTO();

	/**
	 * Default constructor.
	 */
	public ServicioCommonImpl() {
		// TODO Auto-generated constructor stub
	}

	@Override
	public EmpresaDTO getEmpresaPorIdEmpresa(Integer idEmpresaMain)
			throws SeguridadesException {
		log.info("Metodo getEmpresaPorIdEmpresa de la clase ServicioCommonImpl  ");
		try {

			this.empresa = empresaDAO.buscarPorId(idEmpresaMain);
			this.empresaDTO.setIdEmpresa(this.empresa.getIdEmpresa());
			this.empresaDTO.setNombreEmpresa(this.empresa.getNombreEmpresa());
			return this.empresaDTO;
		} catch (Exception e) {
			log.info("Error al obtener  la empresa {}", e.getMessage());
			throw new SeguridadesException("No se pudo actualizar la empresa");
		}
	}

	/**
	 * 
	 * Metodo que permite obtener los cargos de asociados a una empresa que se
	 * tiene en la empresa
	 */
	@Override
	public List<CargoDTO> getCargosPorIdEmpresa(Integer idEmpresaMain)
			throws SeguridadesException {
		log.info("Metodo getCargosPorIdEmpresa de la clase ServicioCommonImpl  ");
		List<TipoPersona> tiposPersona = null;
		List<CargoDTO> cargos = new ArrayList<CargoDTO>();
		try {
			log.info("idEmpresa:  " + idEmpresaMain);

			tiposPersona = tipoPersonaDAO.getCargosPorIdEmpresa(idEmpresaMain);
			for (TipoPersona tipoPersona : tiposPersona) {
				log.info("Nombre tipo persona:  "
						+ tipoPersona.getIdTipoPersona());
				CargoDTO cargo = new CargoDTO();
				cargo.setIdCargo(tipoPersona.getIdTipoPersona());
				cargo.setCargo(tipoPersona.getNombreTipoPersona());
				cargos.add(cargo);
			}
			return cargos;
		} catch (Exception e) {
			log.info("Error al obtener  la empresa {}", e.getMessage());
			throw new SeguridadesException("No se pudo actualizar la empresa");
		}
	}

	@Override
	public List<TipoCampaniaDTO> getTiposCampaniaAsociadasPorIdEmpresa(
			Integer idEmpresaMain) throws SeguridadesException {
		log.info("Metodo getTipoCampaniaAsociadasPorIdEmpresa de la clase ServicioCommonImpl  ");
		List<TipoCampania> tiposCampania = null;
		List<TipoCampaniaDTO> tiposCampaniaDTO = new ArrayList<TipoCampaniaDTO>();
		Empresa empresaTemp = new Empresa();
		try {
			log.info("idEmpresa:  " + idEmpresaMain);
			do {

				tiposCampania = tipoCampaniaDAO
						.getTiposCampaniaPorIdEmpresa(idEmpresaMain);
				for (TipoCampania tipoCampania : tiposCampania) {
					TipoCampaniaDTO tipoCampaniaDTO = new TipoCampaniaDTO();
					tipoCampaniaDTO.setIdTipoCampania(tipoCampania
							.getIdTipoCampania());
					tipoCampaniaDTO.setNombreTipoCampania(tipoCampania
							.getNombreTipoCampania());
					boolean coincideTiposCampania = false;
					for (TipoCampaniaDTO tipoCampaniaDTOtemp : tiposCampaniaDTO) {
						if (tipoCampaniaDTOtemp.idTipoCampania == tipoCampaniaDTO.idTipoCampania)
							coincideTiposCampania = true;
					}
					if (coincideTiposCampania == false)
						tiposCampaniaDTO.add(tipoCampaniaDTO);

				}
				empresaTemp = this.empresaDAO.getEmpresaPorId(idEmpresaMain);
				System.out.println("idEmpresaMain : " + idEmpresaMain);
				if (empresaTemp.getEmpresa() != null)
					idEmpresaMain = empresaTemp.getEmpresa().getIdEmpresa();
				else
					idEmpresaMain = null;
			} while (idEmpresaMain != null);

			return tiposCampaniaDTO;
		} catch (Exception e) {
			log.info(
					"Error al obtener  las campanias asociados a una empresa {}",
					e.getMessage());
			throw new SeguridadesException("No se pudo obtener las campanias");
		}
	}

	@Override
	public List<EmpresaDTO> getEmpresasAsociadasPorIdEmpresa(
			Integer idEmpresaMain) throws SeguridadesException {

		log.info("Metodo getEmpresasAsociadasPorIdEmpresa de la clase ServicioCommonImpl  ");
		List<Empresa> empresasTemp1 = null;
		List<Empresa> empresasTemp2 = new ArrayList<Empresa>();
		List<Empresa> empresas = new ArrayList<Empresa>();
		List<EmpresaDTO> empresasDTO = new ArrayList<EmpresaDTO>();
		Empresa empresaTemp = new Empresa();
		try {
			log.info("idEmpresa:  " + idEmpresaMain);
			do {

				empresasTemp1 = empresaDAO
						.getEmpresasAsociadasPorIdEmpresa(idEmpresaMain);
				empresaTemp=empresaDAO.getEmpresaPorId(idEmpresaMain);
				empresas.add(empresaTemp);
				idEmpresaMain=null;
				if(empresasTemp1 != null) {
					for (int i = 0; i < empresasTemp1.size(); i++) 
						empresasTemp2.add(empresasTemp1.get(i));
					empresasTemp1=null;
					
				}
				if(empresasTemp2!=null){
				idEmpresaMain=empresasTemp2.get(0).getIdEmpresa();
				List<Empresa> empresasTemp3 = new ArrayList<Empresa>();
				if(empresasTemp2.size()>1){
				for (int i = 1; i < empresasTemp2.size(); i++) 
					empresasTemp3.add(empresasTemp2.get(i));
				empresasTemp2=empresasTemp3;
				empresasTemp3=null;
				}else {
					empresasTemp2=null;
					empresasTemp3=null;
				}
				}
				
				if(empresas!=null && idEmpresaMain==null)
				for (Empresa empresa : empresas) {
					EmpresaDTO empresaDTO = new EmpresaDTO();
					empresaDTO.setIdEmpresa(empresa.getIdEmpresa());
					empresaDTO.setNombreEmpresa(empresa.getNombreEmpresa());
					boolean coincideEmpresa = false;
					for (EmpresaDTO empresaDTOtemp : empresasDTO) {
						if (empresaDTOtemp.getIdEmpresa() == empresaDTO
								.getIdEmpresa())
							coincideEmpresa = true;
					}
					if (coincideEmpresa == false)
						empresasDTO.add(empresaDTO);
				}
				
			} while (idEmpresaMain != null);

			return empresasDTO;
		} catch (Exception e) {
			log.info(
					"Error al obtener  las empresas asociadas a una empresa {}",
					e.getMessage());
			throw new SeguridadesException("No se pudo obtener las empresas");
		}
	}

	@Override
	public Boolean verExistenciaCedula(String ci) throws SeguridadesException {
		
		return personaRepetida(ci);
	}

	private Boolean personaRepetida(String ci) throws SeguridadesException {

		// Persona per = personaDAO.getPersonaPorCI(ci);

		if (personaDAO.getPersonaPorCI(ci) != null)
			// Persona per = personaDAO.getPersonaPorCI(ci);
			return Boolean.TRUE;
		else

			return Boolean.TRUE;
	}
	/**
	 * Metodo que permite obtener empleados de la empresa 
	 * @param idEmpresa
	 * @return
	 * @throws SeguridadesException
	 */
	@Override
	public List<EmpleadoDTO> getEmpleadoPorIdEmpresa(Integer idEmpresa)
			throws SeguridadesException {
		log.info("Metodo getEmpleadoPorIdEmpresa de la clase ServicioCommonImpl  ");
		List<EmpleadoDTO> empleadosDTO= new ArrayList<EmpleadoDTO>();
		List<Persona> empleados= new ArrayList<Persona>();
		try {

			empleados = personaDAO.getEmpleadosPorIdEmpresa(idEmpresa);
			for (Persona persona : empleados) {
				EmpleadoDTO empleadoDTO= new EmpleadoDTO();
				empleadoDTO.setIdPersona(persona.getIdPersona());
				empleadoDTO.setIdEmpresa(persona.getEmpresa().getIdEmpresa());
				empleadoDTO.setIdEmpresa(persona.getTipoPersona().getIdTipoPersona());
				empleadoDTO.setNombres(persona.getNombres());
				empleadoDTO.setApellidos(persona.getApellidos());
				empleadoDTO.setCi(persona.getCi());
				empleadoDTO.setTelefono(persona.getTelefono());
				empleadosDTO.add(empleadoDTO);
				
			}
			
			return empleadosDTO;
		} catch (Exception e) {
			log.info("Error al obtener empleados  la empresa {}", e.getMessage());
			throw new SeguridadesException("No se pudo encontrar empleados");
		}
	}
}
